from typing import Any, List, Dict

from pycparser.c_ast import Switch

from Agent.Dispatch.Dao.DispatchRequest import DispatchRequest
from Agent.Dispatch.Dao.DispatchResponse import DispatchResponse
from Agent.FillTable.Service.FillTableService import FillTableService
from Agent.FormAnalyzer.Service.FormAnalyzerService import FormAnalyzerServiceService
from Agent.SecondBarging.Dao.SecondBargainingRequest import SecondBargainingRequest
from Agent.SecondBarging.Dao.SecondBargainingResponse import SecondBargainingResponse
from Core.BaseAgent import BaseAgent
from LlmModel.DoubaoModel.DoubaoModel import DoubaoModel, doubao_model
from utils import logger
from jinja2 import Template
import os

from utils.chat import getUserInput, convert_userInput_to_formDict, convert_formDict_to_userInput
from utils.logger import get_logger

fillTableService = FillTableService()
formAnalyzerServiceService = FormAnalyzerServiceService()
logger = get_logger("SecondBargingController")
baseTable = """1.达人昵称:Doki宋宋（孕期）\n2.达人主页链接:https://www.xiaohongshu.com/user/profile/596e638850c4b475bc3139ce\n3.品牌/产品名称:伊利QQ星\n4.产品品类:伊利奶粉\n5.推广周期:（12月20日前发布）\n6.投放形式:（报备视频80% 报备图文20%）\n7.报备图文价格:\n8.报备视频价格:\n9.是否可以保价到次月:\n10.折扣要求:（30%）\n11.创作方向:（单品种草）\n12.排竞要求:（前 15 后 15）\n13.寄样方式:（寄拍）\n14.出镜小孩性别/年龄:\n15.达人是否处于孕期:\n16.达人场景体验匹配度:\n17.可保阅读数据:（视频保底1万播放，图文保底7000阅读）\n18.可保互动数据:（点赞+评论≥400）\n19.是否可以免费授权品牌信息流 6 个月？:\n20.是否可以免费授权品牌二剪及全平台传播（包括电商）6 个月？:\n21.是否可以免费分发其他平台？:\n22.是否有特殊合作注意事项？（如广告占比要求、脚本修改次数等）:\n23.是否免费授权电商平台植入 6 个月？:\n24.是否授权搜索引导6 个月？:\n25.是否授权带相关话题6 个月？:\n26.是否授权组件需求6 个月？:\n27.是否授权引流需求6 个月？:"""


class SecondBargingService(BaseAgent):
    def __init__(self):
        self.doubaoModel = DoubaoModel()

    async def process(self, input_data: Any) -> Any:
        pass

    async def handle_fill_agent(self, request: SecondBargainingRequest) -> SecondBargainingResponse:
        """
        处理表单填充逻辑

        :param request:
        :return:
        """
        try:
            # 先看他给的是不是表单，他有可能上来就给表单
            user_input = getUserInput(request.conversations)  # 拿到用户本次输入
            is_form = formAnalyzerServiceService._is_form_like(user_input)

            # 先处理**没写过表单**的情况submit==0  && form =={}
            if request.is_submit == 0 and request.form == {}:
                if is_form:
                    # 用户没写过表单，现在他返回来一个表单的情况(填完要进行完整性判断)
                    # （userinput中的"请填写表单\n："replace掉）
                    request.form = convert_userInput_to_formDict(user_input.replace("请填写表单\n：", ""))
                else:
                    # 判断劝告轮次，如果劝告轮次>=2直接 还是劝他填单，不填不给过
                    admonition_count = await self.get_admonition_count(request.conversations)
                    if admonition_count >= 2:
                        return SecondBargainingResponse(
                            agent_response="""球球了活爹，快填表吧，不填不能往下走啊！"""
                        )
                    return SecondBargainingResponse(
                        # 用户习惯直接复制粘贴，下面用户再给内容转成dict之前要把"请填写表单\n：" 这部分replace掉(在convert_userInput_to_formDict已做
                        agent_response="请填写表单\n：" + baseTable
                    )

            """
            这里以后Request.form里面一定会有表单
            下面做完整性校验
            """

            # 下面处理is_submit==0 没过完整性校验 && form!={} 但是填了表，那下面就要去做完整性校验了
            # 看一下哪里缺的，塞到empty里面
            # 缺的让他都给补了，补齐没有差异了才能走
            if request.is_submit == 0 and request.form != {}:
                request.empty_info = formAnalyzerServiceService._check_form_completeness(user_input)
                # print("-------------------------request.empty_info------------------------\n")
                # print(request.empty_info)
                # print("-------------------------request.empty_info------------------------\n")

                if len(request.empty_info) == 0:
                    # 完整性校验过了，后面开始洽谈
                    request.is_submit = 1
                else:
                    # 完整性没写全的让他补！！！！！！！！！！！！
                    return SecondBargainingResponse(
                        form=request.form,
                        agent_response="把表填全了再发过来啊！！！！！！！！！\n",
                    )

            # 下面处理is_submit==1的情况，就是之前提交过表单了，完整性也过了，那直接走差异判断
            if request.is_submit == 1:
                # 剔除 确认合作 已拒品 这两种情况（已经在开始的时候就踢出来了不用管）
                # 剩下就是差异判断了
                # 1、表单前四项一致性检验
                # if is_form:
                #     user_input_form = convert_userInput_to_formDict(user_input.replace("请填写表单\n：", ""))
                #     flag = True
                #     error_info = ""
                #     for key in ["达人昵称", "达人主页链接", "品牌/产品名称", "产品品类"]:
                #         if request.form[key] != user_input_form[key]:
                #             flag = False
                #             error_info += f"{key}不一致\n"
                #             break
                #     if not flag:
                #         return SecondBargainingResponse(
                #             agent_response=f"表单前四项和原来的不一致，请重新填写\n{error_info}"
                #         )


                """
                2、通过大模型进行差异归因（7可处理状态，9不可处理状态）、
                比较两个表单的差异，返回包含两类差异的复合字典
                返回结构说明：
                - negotiable：dict[int, str]，原7个可议价原因（1-7键，值为空=无差异）
                - non_negotiable：dict[int, str]，新增8个不可议价原因（1-8键，值为空=无差异）
                - has_non_negotiable：bool，是否存在不可议价差异（True=有，需优先处理）
                """
                negotiable, non_negotiable, has_non_negotiable = await formAnalyzerServiceService.get_forms_differ_unionDict(
                    baseTable, convert_formDict_to_userInput(request.form), request.conversations
                )

                print("-------------------------negotiable------------------------\n")
                print(negotiable)
                print("-------------------------non_negotiable------------------------\n")
                print(non_negotiable)
                print("-------------------------has_non_negotiable------------------------\n")
                print(has_non_negotiable)
                print("-------------------------has_non_negotiable------------------------\n")




                # 3、根据归因结果进行差异处理（7可处理状态）
                if has_non_negotiable:
                    # 如果有不可议价差异，直接抛出来然后拒掉
                    # 将dict[int, str]的int作为序号，str作为对应的值，然后连成字符串
                    non_negotiable_str = "\n".join(
                        [f"{key}. {value}\n" for key, value in non_negotiable.items() if value]
                    )
                    return SecondBargainingResponse(
                        form=request.form,
                        agent_response="表单有不可议价差异，终止合作！\n" + non_negotiable_str,
                        category="不可议价差异",
                        cooperation_status="已拒品",
                        diff_info={**negotiable, **non_negotiable},
                    )
                else:
                    # 如果没有不可议价差异，则进行可议价差异处理
                    # 7个可以议价的情况：返点不满足、排竞时长不满足、需求不匹配、档期不满足、创作风格不符合、数据不保证、调性不匹配
                    # 为每个情况给出一个处理函数，根据value值去进行调用

                    # 获得request.conversations这个list的最后2or3轮对话
                    if len(request.conversations) >= 6:
                        recent_conversations = request.conversations[-6:]
                    elif len(request.conversations) >= 4:
                        recent_conversations = request.conversations[-4:]
                    else:
                        recent_conversations = request.conversations

                    if "返点不满足" in negotiable.values():
                        chat_state, resp = self.barging_count(recent_conversations)
                        if chat_state == 1:
                            # 聊成功了，把这个从diff_info里面删掉
                            del negotiable["返点不满足"]

                            # 如果diff_info里面还有那就补上一句还有其他的待谈
                            chat_supply = ""
                            if len(negotiable) > 0:
                                chat_supply = "这个谈完了还有其他的得谈:\n" + "\n".join(
                                    [f"{key}. {value}\n" for key, value in negotiable.items() if value]
                                )
                                """
                                      注意：user很可能就接着聊其他的差异的内容，我们后面要考虑怎么通过设置一些状态码去直接到达这里，接着处理下面的逻辑，而不是从头再计算一遍diff_info
                                """

                                return SecondBargainingResponse(
                                    form=request.form,
                                    agent_response=resp + chat_supply,
                                    diff_info=negotiable
                                )
                            else:
                                # 没其他差异了，直接合作成功
                                return SecondBargainingResponse(
                                    form=request.form,
                                    agent_response=resp,
                                    cooperation_status="合作成功"
                                )
                        if chat_state == 0:
                            # 两轮谈不拢，直接拒掉了
                            # 没其他差异了，直接合作成功
                            return SecondBargainingResponse(
                                form=request.form,
                                agent_response=resp,
                                cooperation_status="已拒品",
                                diff_info={**negotiable, **non_negotiable}
                            )
                        if chat_state == 3:
                            # 只聊了1轮，还得再聊
                            return SecondBargainingResponse(
                                form=request.form,
                                agent_response=resp,
                                diff_info=negotiable
                            )
                    if "排竞时长不满足" in negotiable.values():
                        chat_state, resp = self.barging_time(recent_conversations)
                        if chat_state == 1:
                            # 聊成功了，把这个从diff_info里面删掉
                            del negotiable["排竞时长不满足"]

                            # 如果diff_info里面还有那就补上一句还有其他的待谈
                            chat_supply = ""
                            if len(negotiable) > 0:
                                chat_supply = "这个谈完了还有其他的得谈:\n" + "\n".join(
                                    [f"{key}. {value}\n" for key, value in negotiable.items() if value]
                                )
                                """
                                      注意：user很可能就接着聊其他的差异的内容，我们后面要考虑怎么通过设置一些状态码去直接到达这里，接着处理下面的逻辑，而不是从头再计算一遍diff_info
                                """

                                return SecondBargainingResponse(
                                    form=request.form,
                                    agent_response=resp + chat_supply,
                                    diff_info=negotiable
                                )
                            else:
                                # 没其他差异了，直接合作成功
                                return SecondBargainingResponse(
                                    form=request.form,
                                    agent_response=resp,
                                    cooperation_status="合作成功"
                                )
                        if chat_state == 0:
                            # 两轮谈不拢，直接拒掉了
                            # 没其他差异了，直接合作成功
                            return SecondBargainingResponse(
                                form=request.form,
                                agent_response=resp,
                                cooperation_status="已拒品",
                                diff_info={**negotiable, **non_negotiable}
                            )
                        if chat_state == 3:
                            # 只聊了1轮，还得再聊
                            return SecondBargainingResponse(
                                form=request.form,
                                agent_response=resp,
                                diff_info=negotiable
                            )
                    if "需求不匹配" in negotiable.values():
                        chat_state, resp = self.barging_demand(recent_conversations)
                        if chat_state == 1:
                            # 聊成功了，把这个从diff_info里面删掉
                            del negotiable["需求不匹配"]

                            # 如果diff_info里面还有那就补上一句还有其他的待谈
                            chat_supply = ""
                            if len(negotiable) > 0:
                                chat_supply = "这个谈完了还有其他的得谈:\n" + "\n".join(
                                    [f"{key}. {value}\n" for key, value in negotiable.items() if value]
                                )
                                """
                                      注意：user很可能就接着聊其他的差异的内容，我们后面要考虑怎么通过设置一些状态码去直接到达这里，接着处理下面的逻辑，而不是从头再计算一遍diff_info
                                """

                                return SecondBargainingResponse(
                                    form=request.form,
                                    agent_response=resp + chat_supply,
                                    diff_info=negotiable
                                )
                            else:
                                # 没其他差异了，直接合作成功
                                return SecondBargainingResponse(
                                    form=request.form,
                                    agent_response=resp,
                                    cooperation_status="合作成功"
                                )
                        if chat_state == 0:
                            # 两轮谈不拢，直接拒掉了
                            # 没其他差异了，直接合作成功
                            return SecondBargainingResponse(
                                form=request.form,
                                agent_response=resp,
                                cooperation_status="已拒品",
                                diff_info={**negotiable, **non_negotiable}
                            )
                        if chat_state == 3:
                            # 只聊了1轮，还得再聊
                            return SecondBargainingResponse(
                                form=request.form,
                                agent_response=resp,
                                diff_info=negotiable
                            )
                    if "档期不满足" in negotiable.values():
                        chat_state, resp = self.barging_count(recent_conversations)
                        if chat_state == 1:
                            # 聊成功了，把这个从diff_info里面删掉
                            del negotiable["档期不满足"]

                            # 如果diff_info里面还有那就补上一句还有其他的待谈
                            chat_supply = ""
                            if len(negotiable) > 0:
                                chat_supply = "这个谈完了还有其他的得谈:\n" + "\n".join(
                                    [f"{key}. {value}\n" for key, value in negotiable.items() if value]
                                )
                                """
                                      注意：user很可能就接着聊其他的差异的内容，我们后面要考虑怎么通过设置一些状态码去直接到达这里，接着处理下面的逻辑，而不是从头再计算一遍diff_info
                                """

                                return SecondBargainingResponse(
                                    form=request.form,
                                    agent_response=resp + chat_supply,
                                    diff_info=negotiable
                                )
                            else:
                                # 没其他差异了，直接合作成功
                                return SecondBargainingResponse(
                                    form=request.form,
                                    agent_response=resp,
                                    cooperation_status="合作成功"
                                )
                        if chat_state == 0:
                            # 两轮谈不拢，直接拒掉了
                            # 没其他差异了，直接合作成功
                            return SecondBargainingResponse(
                                form=request.form,
                                agent_response=resp,
                                cooperation_status="已拒品",
                                diff_info={**negotiable, **non_negotiable}
                            )
                        if chat_state == 3:
                            # 只聊了1轮，还得再聊
                            return SecondBargainingResponse(
                                form=request.form,
                                agent_response=resp,
                                diff_info=negotiable
                            )
                    if "创作风格不符合" in negotiable.values():
                        chat_state, resp = self.barging_style(recent_conversations)
                        if chat_state == 1:
                            # 聊成功了，把这个从diff_info里面删掉
                            del negotiable["创作风格不符合"]

                            # 如果diff_info里面还有那就补上一句还有其他的待谈
                            chat_supply = ""
                            if len(negotiable) > 0:
                                chat_supply = "这个谈完了还有其他的得谈:\n" + "\n".join(
                                    [f"{key}. {value}\n" for key, value in negotiable.items() if value]
                                )
                                """
                                      注意：user很可能就接着聊其他的差异的内容，我们后面要考虑怎么通过设置一些状态码去直接到达这里，接着处理下面的逻辑，而不是从头再计算一遍diff_info
                                """

                                return SecondBargainingResponse(
                                    form=request.form,
                                    agent_response=resp + chat_supply,
                                    diff_info=negotiable
                                )
                            else:
                                # 没其他差异了，直接合作成功
                                return SecondBargainingResponse(
                                    form=request.form,
                                    agent_response=resp,
                                    cooperation_status="合作成功"
                                )
                        if chat_state == 0:
                            # 两轮谈不拢，直接拒掉了
                            # 没其他差异了，直接合作成功
                            return SecondBargainingResponse(
                                form=request.form,
                                agent_response=resp,
                                cooperation_status="已拒品",
                                diff_info={**negotiable, **non_negotiable}
                            )
                        if chat_state == 3:
                            # 只聊了1轮，还得再聊
                            return SecondBargainingResponse(
                                form=request.form,
                                agent_response=resp,
                                diff_info=negotiable
                            )
                    if "数据不保证" in negotiable.values():
                        chat_state, resp = self.barging_data_guarantee(recent_conversations)
                        if chat_state == 1:
                            # 聊成功了，把这个从diff_info里面删掉
                            del negotiable["数据不保证"]

                            # 如果diff_info里面还有那就补上一句还有其他的待谈
                            chat_supply = ""
                            if len(negotiable) > 0:
                                chat_supply = "这个谈完了还有其他的得谈:\n" + "\n".join(
                                    [f"{key}. {value}\n" for key, value in negotiable.items() if value]
                                )
                                """
                                      注意：user很可能就接着聊其他的差异的内容，我们后面要考虑怎么通过设置一些状态码去直接到达这里，接着处理下面的逻辑，而不是从头再计算一遍diff_info
                                """

                                return SecondBargainingResponse(
                                    form=request.form,
                                    agent_response=resp + chat_supply,
                                    diff_info=negotiable
                                )
                            else:
                                # 没其他差异了，直接合作成功
                                return SecondBargainingResponse(
                                    form=request.form,
                                    agent_response=resp,
                                    cooperation_status="合作成功"
                                )
                        if chat_state == 0:
                            # 两轮谈不拢，直接拒掉了
                            # 没其他差异了，直接合作成功
                            return SecondBargainingResponse(
                                form=request.form,
                                agent_response=resp,
                                cooperation_status="已拒品",
                                diff_info={**negotiable, **non_negotiable}
                            )
                        if chat_state == 3:
                            # 只聊了1轮，还得再聊
                            return SecondBargainingResponse(
                                form=request.form,
                                agent_response=resp,
                                diff_info=negotiable
                            )
                    if "调性不匹配" in negotiable.values():
                        chat_state, resp = self.barging_tone(recent_conversations)
                        if chat_state == 1:
                            # 聊成功了，把这个从diff_info里面删掉
                            del negotiable["调性不匹配"]

                            # 如果diff_info里面还有那就补上一句还有其他的待谈
                            chat_supply = ""
                            if len(negotiable) > 0:
                                chat_supply = "这个谈完了还有其他的得谈:\n" + "\n".join(
                                    [f"{key}. {value}\n" for key, value in negotiable.items() if value]
                                )
                                """
                                      注意：user很可能就接着聊其他的差异的内容，我们后面要考虑怎么通过设置一些状态码去直接到达这里，接着处理下面的逻辑，而不是从头再计算一遍diff_info
                                """

                                return SecondBargainingResponse(
                                    form=request.form,
                                    agent_response=resp + chat_supply,
                                    diff_info=negotiable
                                )
                            else:
                                # 没其他差异了，直接合作成功
                                return SecondBargainingResponse(
                                    form=request.form,
                                    agent_response=resp,
                                    cooperation_status="合作成功"
                                )
                        if chat_state == 0:
                            # 两轮谈不拢，直接拒掉了
                            # 没其他差异了，直接合作成功
                            return SecondBargainingResponse(
                                form=request.form,
                                agent_response=resp,
                                cooperation_status="已拒品",
                                diff_info={**negotiable, **non_negotiable}
                            )
                        if chat_state == 3:
                            # 只聊了1轮，还得再聊
                            return SecondBargainingResponse(
                                form=request.form,
                                agent_response=resp,
                                diff_info=negotiable
                            )

            return SecondBargainingResponse(
                agent_response="默认情况"
            )

        except Exception as e:
            logger.error(f"Error in fill agent flow: {str(e)}")
            return SecondBargainingResponse(
                form=request.form,
                agent_response="",
                status="",
                reference="666",
                category=request.category,  # 拒绝原因
                subcategory=request.subcategory,  # 小类
                cooperation_status=request.cooperation_status,  # 合作状态大类
                is_first=request.is_first
            )

    async def _handle_global_qa(self, request):
        pass

    async def get_admonition_count(self, conversations: List[Dict[str, str]]) -> int:
        """
        使用大模型统计劝用户填表的次数

        :param conversations: 对话历史记录
        :return: 劝用户填表的次数
        """
        try:
            # 按时间顺序拼接对话内容
            conversation_text = "\n".join([
                f"{msg.get('role', '')}: {msg.get('content', '')}"
                for msg in conversations
            ])

            # 构建判断提示词
            prompt = f"""请分析以下对话内容，统计系统（assistant）劝用户填写表单的次数。

    判断标准：
    1. 当assistant提醒用户需要补充表单信息
    2. 当assistant指出表单不完整
    3. 当assistant要求用户填写或完善表单

    对话内容：
    {conversation_text}

    请只返回一个数字，表示劝用户填表的次数。如果没有找到相关内容，返回0。"""

            # 调用大模型
            response = await self.doubaoModel.generate_text(prompt)

            # 尝试解析返回的数字
            try:
                count = int(response.strip())
                return count
            except ValueError:
                # logger.warning(f"大模型返回的劝填表次数格式不正确: {response}")
                return 0

        except Exception as e:
            # logger.error(f"统计劝填表次数失败: {str(e)}")
            return 0

    async def barging_tone(self, conversations: List[Dict[str, str]]):
        try:
            # 按时间顺序拼接对话内容
            conversation_text = "\n".join([
                f"{msg.get('role', '')}: {msg.get('content', '')}"
                for msg in conversations
            ])

            # 构建判断提示词
            prompt = f"""

                        当博主回复中包含“账号与品牌调性不匹配”或“账号粉丝人群与品牌不匹配”或类似大意时（例如，“我觉得我的账号不太适合你们的品牌”“粉丝群体可能不匹配”等），基于用户填写的表单数据，生成一个回复消息。回复必须：
                        - 以“宝子，你好！”开头，保持亲切、友好的语气。
                        - 首先表达理解和感谢博主的诚实反馈，简要承认博主的顾虑。
                        - 针对具体回复内容进行解释和说服：
                          - 如果博主提到“账号与品牌调性不匹配”，则强调品牌的可调整性、博主的独特价值或产品品类的灵活性，引用表单中的“品牌/产品名称”“产品品类”“创作方向”等字段，说明如何通过定制化合作来适配。
                          - 如果博主提到“账号粉丝人群与品牌不匹配”，则引用表单中的“可保阅读数据”“可保互动数据”“创作方向”等字段，提供数据或理由说明粉丝人群可能存在的重叠，或建议调整推广方式。
                        - 邀请进一步讨论，提出灵活合作方案，例如调整“投放形式”“折扣要求”或“创作方向”，并提及表单中的优惠信息（如“报备图文价格”“报备视频价格”“免费展示套数及加价”等）以增加吸引力。
                        - 结束时，鼓励博主继续沟通，询问是否愿意细化合作细节。
                        - 整体回复长度控制在150-200字，确保自然流畅，避免机械式列表。

                        回复模板示例（AI需根据实际情况动态填充占位符）：
                        “宝子，你好！非常感谢你坦诚地分享你的想法～我完全理解你觉得"达人昵称"的账号与"品牌/产品名称"的调性可能不太匹配，但我们的"产品品类"其实在"创作方向"上有很多创意空间，可以完美结合你的独特风格呢！另外，你的粉丝数据（比如"可保阅读数据"阅读和"可保互动数据"互动）显示你的受众超级活跃，很可能与我们的目标用户有重叠哦。我们可以一起调整"投放形式"或"折扣要求"，让合作更贴心～而且，我们还有"报备图文价格"等优惠，包括"免费展示套数及加价"等权益。宝子，要不要我们再聊聊细节？看看怎么定制最适合你的方案？😊”

                        注意：
                        - 在生成回复时，你需优先引用与博主回复最相关的表单字段（例如，如果博主强调调性，就多提“创作方向”；如果强调粉丝，就多提数据字段）。
                        - 如果表单中某些字段为空或未提供，就应跳过该部分，保持回复连贯。
                        - 回复中可适当使用表情符号增强亲和力，但不要过度。
                        - 回复不要表现出你是AI，而是以合作者身份回复，语气亲切、自然。
                        - 确保回复基于博主实际对话内容——如果博主回复更具体，需调整重点，例如博主说“我的粉丝主要是年轻人，而品牌偏成熟”，则针对性解释品牌如何吸引年轻群体。

                        请按照上面的要求并分析以下对话内容给出合适的回复，并且还要根据以下对话内容判断是进行了几轮对话
                        如果是第一轮对话谈成功了就返回数字1
                        如果是第一轮对话并且没有第二轮对话谈失败了就返回数字3
                        如果是第二轮对话谈成功了就返回数字1
                        如果是第二轮对话谈失败了就返回数字0
                        先回复判断的状态数字，在正常回复
                {conversation_text}

                """

            # 调用大模型
            response = await self.doubaoModel.generate_text(prompt)
            # 分离状态数字和回复内容
            status1 = response.strip()[0]  # 获取第一个字符作为状态
            # 把status转为int型
            status = int(status1)
            reply = response.strip()[1:]  # 获取剩余部分作为回复内容
            return status, reply

        except Exception as e:
            return -1, f"运行出错: {str(e)}"

    async def barging_demand(self, conversations: List[Dict[str, str]]):
        try:
            # 按时间顺序拼接对话内容
            conversation_text = "\n".join([
                f"{msg.get('role', '')}: {msg.get('content', '')}"
                for msg in conversations
            ])

            # 构建判断提示词
            prompt = f"""

            当博主回复中包含以下需求不匹配情况时：
            - "只接图文，不接视频"/"只接视频，不接图文"
            - "没接过这类的品，暂不考虑"
            - "没做过线下探店，我只做线上种草内容"
            - "这个产品不适合做视频"
            或类似大意的回复

            请基于用户填写的表单数据，生成一个友好且灵活的回复消息。回复要求：
            1. 以“宝子，你好！”开头，语气亲切自然
            2. 首先表达理解和尊重博主的创作习惯
            3. 针对具体问题提供解决方案：

            • 如果博主偏好某种内容形式（图文/视频）：
               “完全理解宝子对”投放形式”的偏好！其实我们”品牌/产品名称”的”产品品类”在”创作方向”上，”图文/视频”都能很好展现呢～如果你目前只想做”图文/视频”，我们可以按照”报备图文价格/报备视频价格”来调整合作方案”

            • 如果博主表示没接过这类产品：
               “谢谢宝子的坦诚！很多博主第一次接触”产品品类”都有类似想法，但最后效果都很惊喜呢～我们可以根据你的”创作方向”来定制内容，”寄样方式”也很方便，还能”免费展示套数及加价””

            • 如果博主只做线上不做线下：
               “明白宝子专注线上内容！我们的合作完全可以线上完成，通过”寄样方式”寄送产品，你按照”创作方向”创作”投放形式”就好～还有”可保阅读数据”阅读数据保障呢”

            • 如果博主认为产品不适合视频：
               “理解宝子的顾虑！其实”产品品类”通过视频能更好展示”创作方向”呢，我们可以提供详细的视频参考，而且”报备视频价格”也很优惠，还包含”免费授权品牌信息流6个月”等权益”

            4. 突出合作优势：
               - 提及价格优势：”报备图文价格”/”报备视频价格”
               - 数据保障：”可保阅读数据”/”可保互动数据”
               - 免费权益：”免费展示套数及加价”、各项授权权益
               - 灵活调整：可根据”折扣要求”、”创作方向”等灵活调整

            5. 结尾邀请进一步沟通：
               “宝子要不要我们再详细聊聊？看看怎么调整最能满足你的需求～期待能找到双方都满意的合作方式！😊”

            注意事项：
            - 根据博主具体回复重点选择最相关的3-4个表单字段引用
            - 保持回复长度在180-250字
            - 回复中可适当使用表情符号增强亲和力，但不要过度。
            - 如果某些字段为空，自动跳过相关部分
            - 回复不要表现出你是AI，而是以合作者身份回复，语气亲切、自然。
            - 确保回复针对博主的具体顾虑进行解答。

            #### 状态判断逻辑：
            - 基于对话历史（假设消息序列按顺序提供，每条消息有发送者“品牌方”或“博主”和内容）。
            - 计算博主回复的消息数量：
            - 如果这是第一个博主回复（即对话历史中只有一个博主消息），且回复内容表示同意合作（如包含“好”、“同意”、“可以”、“合作”等正面关键词），输出数字1。
            - 如果这是第一个博主回复，且回复内容表示拒绝合作（如包含“不”、“拒绝”、“不匹配”、“不适合”等负面关键词），并且对话历史中只有两个消息（品牌方初始消息和博主回复），输出数字3。
            - 如果这是第二个博主回复（即对话历史中有两个博主消息），且回复内容表示同意合作，输出数字1。
            - 如果这是第二个博主回复，且回复内容表示拒绝合作，输出数字0。
            - 如果对话轮次超过第二轮，默认输出数字0（视为失败），但重点处理第一轮和第二轮。
            注意先回复判断的状态数字，在正常回复
    {conversation_text}

    """

            # 调用大模型
            response = await doubao_model.generate_text(prompt)
            # 分离状态数字和回复内容
            status1 = response.strip()[0]  # 获取第一个字符作为状态
            # 把status转为int型
            status = int(status1)
            reply = response.strip()[1:]  # 获取剩余部分作为回复内容
            return status, reply

        except Exception as e:
            return -1, f"运行出错: {str(e)}"

    async def barging_data_guarantee(self, conversations: List[Dict[str, str]]):
        """
        使用大模型计算"数据不保证"的讨论轮次和生成回复

        :param conversations: 对话历史记录
        :return: 状态码和回复语句的元组
        """
        # 数据不保证轮次判断提示词
        data_guarantee_prompt = f"""
    请分析以下对话历史，判断数据保证讨论的轮次和是否达成一致。

    对话历史：
    {conversations}

    一、前置过滤：聚焦数据保证相关讨论
        逐句扫描对话历史：对 {conversations} 中每一条消息（user/assistant），主要关注是否包含数据保证相关讨论。
        数据保证相关关键词包括但不限于：
        数据相关：数据、效果、播放量、阅读量、互动量、转化、承诺、保证、保底
        否定相关：不保证、不能保证、没法承诺、不承诺、波动大、不稳定
        其他：只要对话内容涉及数据效果承诺、数据保证能力等话题，都应纳入考虑

    二、轮次分组：按"助手→用户"顺序寻找数据保证讨论
        分组规则：从最新对话开始，寻找所有包含数据保证讨论的"assistant 消息 + user 消息"组合。
        不要求连续：即使中间有其他话题的讨论，只要找到数据保证相关的对话对，就纳入计数。
        分组数量：不设上限，但只统计数据保证相关的对话对。

    三、有效轮次判定（每组独立判断）
        对每一组数据保证相关的"assistant+user"对话对，需同时满足以下条件，才算1个有效轮次：
        assistant 端：涉及数据保证引导或询问
            包含数据保证相关关键词或明显在讨论数据效果；
            包含引导用户提供数据承诺或填写数据的意图；
            示例："你的商单数据一般能保多少""看看您数据常规能保多少""先填表报个名"
        user 端：针对数据保证的明确回应
            是对当前assistant数据保证引导的直接回应；
            包含明确的数据保证态度或数据承诺；
            示例："我不能保证推广后的数据效果""数据波动大，没法承诺转化""不承诺数据"

    四、达成一致判定
        检查最新一轮用户消息是否明确表示接受合作或提供数据：
        接受关键词：接受、同意、可以、行、好吧、没问题、确定了、合作、定了吧、就这样、按你们要求
        如果用户明确接受合作或提供数据承诺，则视为达成一致

    五、轮次统计和状态判断
        扫描整个对话历史，找出所有有效的数据保证讨论轮次；
        根据轮次和是否达成一致，返回以下状态码：

        状态码规则：
            0：无有效数据保证讨论轮次，或有效轮次超过2轮仍未达成一致
            1：讨论了1轮或2轮且达成了一致意见
            2：仅讨论了1轮且没有达成一致意见

        注意：只有状态码1代表达成一致意见

    六、最终输出
        仅返回状态码数字（0、1或2），无任何其他字符。
    """

        try:
            # 调用大模型获取数据保证轮次结果
            data_guarantee_result = await self.doubaoModel.generate_text(data_guarantee_prompt)

            # 解析状态码
            try:
                status_code = int(data_guarantee_result.strip())
                # 确保状态码在有效范围内
                if status_code not in [0, 1, 2]:
                    status_code = 0
            except (ValueError, TypeError):
                logger.error(f"无法解析数据保证轮次状态码: {data_guarantee_result}")
                status_code = 0

            # 根据状态码生成相应的回复
            if status_code == 0:
                # 无有效讨论或超过2轮未达成一致
                agent_response = "好的宝子，已记录"
            elif status_code == 1:
                # 达成一致意见
                agent_response = "宝子，烦您核对信息是否准确，有无遗漏～"
            elif status_code == 2:
                # 仅讨论1轮未达成一致
                agent_response = "宝子，你的商单数据一般能保多少，可以填写到表单内先报个名哈～"

            logger.info(f"【数据不保证】大模型返回状态码: {status_code}")

            # 返回结果：状态码在第一位，回复语句在第二位
            return status_code, agent_response

        except Exception as e:
            logger.error(f"计算数据不保证轮次失败: {str(e)}")
            # 异常时返回默认值
            return 0, "好的宝子，已记录"

    async def barging_style(self,conversations: List[Dict[str, str]]):
        try:
            # 按时间顺序拼接对话内容
            conversation_text = "\n".join([
                f"{msg.get('role', '')}: {msg.get('content', '')}"
                for msg in conversations
            ])

            # 构建判断提示词
            prompt = f"""

            你是一个与小红书博主沟通合作的 AI 助手，负责处理博主对合作提议的回复。当博主表示其创作风格与品牌需求不匹配时（例如博主回复 “我这边做种草为主，测评不是特别善长”），请基于用户提供的表单数据和博主的实际回复内容，生成一个友好、专业的回复。回复必须符合以下要求：
            称呼博主为 “宝子”，以体现亲切感。
            直接引用或参考博主回复中的关键内容（例如 “您提到您主要以种草为主，不擅长测评”），以显示你认真聆听了他们的反馈。
            结合表单字段信息，尝试协商调整合作方式，或礼貌地处理风格不匹配问题（例如，如果品牌的创作方向要求测评，但博主不擅长，可以建议聚焦种草方向，或询问灵活性）。
            回复语言保持自然、鼓励性，避免生硬拒绝，优先探索合作可能性。
            根据表单数据，提及相关字段（如创作方向、产品品类、推广周期等），以个性化回复。
            表单字段参考（用户填写的数据）：
            达人昵称：“达人昵称”
            达人主页链接：“达人主页链接”
            品牌 / 产品名称：“品牌 / 产品名称”
            产品品类：“产品品类”
            推广周期：“推广周期”
            投放形式：“投放形式”
            报备图文价格：“报备图文价格”
            报备视频价格：“报备视频价格”
            是否可以保价到次月：“是否可以保价到次月”
            折扣要求：“折扣要求”
            创作方向：“创作方向”（关键字段：用于对比博主风格）
            排竞要求：“排竞要求”
            寄样方式：“寄样方式”
            达人鞋服尺码：“达人鞋服尺码”
            免费展示套数及加价：“免费展示套数及加价”
            可保阅读数据：“可保阅读数据”
            可保互动数据：“可保互动数据”
            是否可以免费授权品牌信息流 6 个月：“是否可以免费授权品牌信息流 6 个月”
            是否可以免费授权品牌二剪及全平台传播（包括电商）6 个月：“是否可以免费授权品牌二剪及全平台传播（包括电商）6 个月”
            是否可以免费分发其他平台：“是否可以免费分发其他平台”
            是否有特殊合作注意事项：“是否有特殊合作注意事项”
            是否免费授权电商平台植入 6 个月：“是否免费授权电商平台植入 6 个月”
            是否授权搜索引导 6 个月：“是否授权搜索引导 6 个月”
            是否授权带相关话题 6 个月：“是否授权带相关话题 6 个月”
            是否授权组件需求 6 个月：“是否授权组件需求 6 个月”
            是否授权引流需求 6 个月：“是否授权引流需求 6 个月”
            回复生成指南：
            首先，确认博主的回复，并表达理解（例如：“宝子，感谢您的坦诚反馈！”）。
            然后，对比表单中的 “创作方向” 字段：如果博主的种草风格与品牌需求一致，可以强调合作点；如果不一致（如品牌需要测评），则尝试调整（例如询问博主是否愿意尝试轻度测评，或聚焦纯种草内容）。
            引用表单中其他相关字段来定制提议（例如，如果产品品类适合种草，可以突出这一点；或根据推广周期和折扣要求提供灵活方案）。
            如果风格严重不匹配且无法调整，礼貌结束对话，并留下未来合作空间。
            确保回复简洁、积极，字数控制在 150-200 字内。
            如果某些字段为空，自动跳过相关部分
            示例回复结构（基于博主回复 “我这边做种草为主，测评不是特别善长”）：“宝子，您好！感谢您分享您的创作偏好，您提到您主要以种草为主，不擅长测评，这让我们更了解您的风格。针对我们的品牌 “品牌 / 产品名称”（品类：“产品品类”），原本的创作方向是 “创作方向”，但如果您更擅长种草，我们可以调整内容聚焦于真实体验和推荐，避免硬核测评。同时，我们的推广周期是 “推广周期”，投放形式为 “投放形式”，如果您有兴趣，我们可以讨论报备图文或视频的细节（价格：图文 “报备图文价格”，视频 “报备视频价格”）。另外，关于授权和数据方面（如免费授权信息流 6 个月：“是否可以免费授权品牌信息流 6 个月”），我们会尽量满足您的需求。期待您的进一步想法，我们可以一起打造适合的合作！”

            #### 状态判断逻辑：
            - 基于对话历史（假设消息序列按顺序提供，每条消息有发送者“品牌方”或“博主”和内容）。
            - 计算博主回复的消息数量：
            - 如果这是第一个博主回复（即对话历史中只有一个博主消息），且回复内容表示同意合作（如包含“好”、“同意”、“可以”、“合作”等正面关键词），输出数字1。
            - 如果这是第一个博主回复，且回复内容表示拒绝合作（如包含“不”、“拒绝”、“不匹配”、“不适合”等负面关键词），并且对话历史中只有两个消息（品牌方初始消息和博主回复），输出数字3。
            - 如果这是第二个博主回复（即对话历史中有两个博主消息），且回复内容表示同意合作，输出数字1。
            - 如果这是第二个博主回复，且回复内容表示拒绝合作，输出数字0。
            - 如果对话轮次超过第二轮，默认输出数字0（视为失败），但重点处理第一轮和第二轮。
            注意一定要先回复判断的状态数字，在正常回复
    {conversation_text}

    """

            # 调用大模型
            response = await doubao_model.generate_text(prompt)
            # 分离状态数字和回复内容
            status1 = response.strip()[0]  # 获取第一个字符作为状态
            # 把status转为int型
            status = int(status1)
            reply = response.strip()[1:]  # 获取剩余部分作为回复内容
            return status, reply

        except Exception as e:
            return -1, f"运行出错: {str(e)}"


    async def barging_time(self,conversations: List[Dict[str, str]]):
        try:
            # 按时间顺序拼接对话内容
            conversation_text = "\n".join([
                f"{msg.get('role', '')}: {msg.get('content', '')}"
                for msg in conversations
            ])

            # 构建判断提示词
            prompt = f"""

            # 针对博主排竞相关问题的AI智能回复提示词
            当博主回复中包含以下排竞相关问题时：
            - "我近期刚接了个类似的品，排竞时长满足不了"
            - "我没接过这类的品，暂不考虑哈"
            - "排竞一般是前7后7"
            或类似大意的回复

            请基于用户填写的表单数据，生成一个专业且灵活的回复消息。回复要求：

            1. 以"宝子，你好！"开头，语气理解且温和
            2. 针对具体问题进行回应：

            • 如果博主提到刚接类似品、排竞时长冲突：
               "完全理解宝子对排竞的顾虑！看到你近期接了同类产品，确实需要合理安排时间。我们的“排竞要求”可以灵活调整，“推广周期”也能根据你的档期来协调～"

            • 如果博主表示没接过这类产品：
               "谢谢宝子的坦诚！其实很多博主第一次合作“产品品类”都有惊喜呢～我们的“排竞要求”相对宽松，“创作方向”也可以按你的风格来定，不会受过往经验影响"

            • 如果博主提出具体排竞要求（如前7后7）：
               "明白宝子的排竞习惯！我们目前的“排竞要求”确实有些差异，但可以根据你的需求调整。“推广周期”和投放时间都可以协商，确保不影响你其他合作"

            3. 提供解决方案和优势：
               - 强调排竞灵活性："我们可以重新商议“排竞要求”，在“推广周期”内找到合适的时间点"
               - 提及合作价值："除了“报备图文价格”/“报备视频价格”的优惠，还有“免费展示套数及加价”等权益"
               - 数据保障："合作期间我们会保障“可保阅读数据”阅读和“可保互动数据”互动"
               - 样品支持："通过“寄样方式”寄送样品，“达人鞋服尺码”我们都会准确准备"

            4. 差异化说服：
               "虽然“品牌/产品名称”属于“产品品类”，但在“创作方向”上有很多独特亮点，与其他同类产品有很大区别呢～"

            5. 结尾邀请进一步沟通：
               "宝子，我们要不具体聊聊你的排竞需求？看看怎么调整最能配合你的档期～期待能找到共赢的合作方案！😊"

            注意事项：
            - 重点引用“排竞要求”、“推广周期”、“产品品类”等核心字段
            - 保持回复长度在160-220字
            - 语气要体现理解和专业性
            - 如果博主提出具体排竞时长，要在回复中体现协商意愿
            - 适当使用表情符号增强亲和力
            - 空字段自动跳过，保持语句连贯

            #### 状态判断逻辑：
            - 基于对话历史（假设消息序列按顺序提供，每条消息有发送者“品牌方”或“博主”和内容）。
            - 计算博主回复的消息数量：
            - 如果这是第一个博主回复（即对话历史中只有一个博主消息），且回复内容表示同意合作（如包含“好”、“同意”、“可以”、“合作”等正面关键词），输出数字1。
            - 如果这是第一个博主回复，且回复内容表示拒绝合作（如包含“不”、“拒绝”、“不匹配”、“不适合”等负面关键词），并且对话历史中只有两个消息（品牌方初始消息和博主回复），输出数字3。
            - 如果这是第二个博主回复（即对话历史中有两个博主消息），且回复内容表示同意合作，输出数字1。
            - 如果这是第二个博主回复，且回复内容表示拒绝合作，输出数字0。
            - 如果对话轮次超过第二轮，默认输出数字0（视为失败），但重点处理第一轮和第二轮。
            注意一定要先回复判断的状态数字，在正常回复
    {conversation_text}

    """

            # 调用大模型
            response = await self.doubaoModel.generate_text(prompt)
            # 分离状态数字和回复内容
            status1 = response.strip()[0]  # 获取第一个字符作为状态
            # 把status转为int型
            status = int(status1)
            reply = response.strip()[1:]  # 获取剩余部分作为回复内容
            return status, reply

        except Exception as e:
            return -1, f"运行出错: {str(e)}"




